home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / CPP / WFC010.ZIP / SRC / DUMYFILE.CPP < prev    next >
C/C++ Source or Header  |  1995-12-07  |  4KB  |  183 lines
  1. #include <wfc.h>
  2. #pragma hdrstop
  3.  
  4. /*
  5. ** Author: Samuel R. Blackburn
  6. ** CI$: 76300,326
  7. ** Internet: sammy@sed.csc.com
  8. **
  9. ** You can use it any way you like as long as you don't try to sell it.
  10. **
  11. ** Any attempt to sell WFC in source code form must have the permission
  12. ** of the original author. You can produce commercial executables with
  13. ** WFC but you can't sell WFC.
  14. **
  15. ** Copyright, 1995, Samuel R. Blackburn
  16. **
  17. ** $Workfile: $
  18. ** $Revision: $
  19. ** $Modtime: $
  20. */
  21.  
  22. #if defined( _DEBUG )
  23. #undef THIS_FILE
  24. static char BASED_CODE THIS_FILE[] = __FILE__;
  25. #endif
  26.  
  27. IMPLEMENT_SERIAL( CDummyFile, CFile, 1 )
  28.  
  29. #if defined( _DEBUG )
  30. #define new DEBUG_NEW
  31. #endif
  32.  
  33. CDummyFile::CDummyFile()
  34. {
  35. }
  36.  
  37. CDummyFile::~CDummyFile()
  38. {
  39.    TRACE( "Destroying a CDummyFile object\n" );
  40.  
  41.    Close();
  42. }
  43.  
  44. void CDummyFile::Abort( void )
  45. {
  46.    Close();
  47. }
  48.  
  49. void CDummyFile::Close( void )
  50. {
  51.    /*
  52.    ** This is here to trap calls that attempt to close an already closed file.
  53.    ** I don't consider this an error but MFC does...
  54.    */
  55.  
  56.    if ( m_hFile != (UINT) hFileNull )
  57.    {
  58.       CFile::Close();
  59.    }
  60. }
  61.  
  62. #if defined( _DEBUG )
  63.  
  64. void CDummyFile::Dump( CDumpContext& dump_context ) const
  65. {
  66.    CFile::Dump( dump_context );
  67.  
  68.    dump_context << "m_ErrorCode = " << m_ErrorCode << "\n";
  69. }
  70.  
  71. #endif // _DEBUG
  72.  
  73. void CDummyFile::Flush( void )
  74. {
  75. }
  76.  
  77. DWORD CDummyFile::GetError( void ) const
  78. {
  79.    return( m_ErrorCode );
  80. }
  81.  
  82. DWORD CDummyFile::GetLength( void ) const
  83. {
  84.    return( 0L );
  85. }
  86.  
  87. DWORD CDummyFile::GetPosition( void ) const
  88. {
  89.    ASSERT( FALSE ); // Unsupported function
  90.    return( 0L );
  91. }
  92.  
  93. #pragma warning( disable : 4100 )
  94.  
  95. BOOL CDummyFile::GetStatus( CFileStatus& status )
  96. {
  97.    return( FALSE );
  98. }
  99.  
  100. BOOL CDummyFile::GetStatus( LPCTSTR Name, CFileStatus& Status )
  101. {
  102.    return( FALSE );
  103. }
  104.  
  105. void CDummyFile::LockRange( DWORD Position, DWORD Count )
  106. {
  107.    ASSERT( FALSE ); // Unsupported function
  108. }
  109.  
  110. void CDummyFile::Remove( LPCTSTR name )
  111. {
  112.    ASSERT( FALSE ); // Unsupported function
  113. }
  114.  
  115. void CDummyFile::Rename( LPCTSTR OldName, LPCTSTR NewName )
  116. {
  117.    ASSERT( FALSE ); // Unsupported function
  118. }
  119.  
  120. #pragma warning( disable : 4100 )
  121.  
  122. LONG CDummyFile::Seek( LONG Offset, UINT From )
  123. {
  124.    ASSERT( FALSE ); // Unsupported function
  125.    return( 0L );
  126. }
  127.  
  128. #pragma warning( default : 4100 )
  129.  
  130. void CDummyFile::Serialize( CArchive& archive )
  131. {
  132.    CFile::Serialize( archive );
  133. }
  134.  
  135. #pragma warning( disable : 4100 )
  136.  
  137. void CDummyFile::SetLength( DWORD length )
  138. {
  139.    ASSERT( FALSE ); // Unsupported function
  140. }
  141.  
  142. void CDummyFile::SetStatus( LPCTSTR name, const CFileStatus& status )
  143. {
  144. }
  145.  
  146. void CDummyFile::UnlockRange( DWORD Position, DWORD Count )
  147. {
  148.    ASSERT( FALSE ); // Unsupported function
  149. }
  150.  
  151. void CDummyFile::Write( const CString& string_to_write )
  152. {
  153.    CFile::Write( (const void *) (LPCTSTR) string_to_write, (UINT) string_to_write.GetLength() );
  154. }
  155.  
  156. void CDummyFile::Write( const CByteArray& data_to_write )
  157. {
  158.    UINT number_of_bytes_to_write = data_to_write.GetSize();
  159.  
  160.    BYTE *buffer = new BYTE[ number_of_bytes_to_write ];
  161.  
  162.    ASSERT( buffer != NULL );
  163.  
  164.    if ( buffer == NULL )
  165.    {
  166.       return;
  167.    }
  168.  
  169.    UINT index = 0;
  170.  
  171.    while( index < number_of_bytes_to_write )
  172.    {
  173.       buffer[ index ] = data_to_write.GetAt( index );
  174.       index++;
  175.    }
  176.  
  177.    CFile::Write( (const void *) buffer, number_of_bytes_to_write );
  178.  
  179.    delete [] buffer;
  180. }
  181.  
  182. #pragma warning( default : 4100 )
  183.